\documentclass[a4paper]{article}

\usepackage[brazil]{babel}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{ae}
\usepackage{graphicx}
\usepackage{float}

\begin{document}

\title{GeBeAH: Emulador de GameBoy Advance\\
		Documentação sobre ARM7TDMI}
\author{}
\date{}
\maketitle

\section{Introdução}
Esse documento é um apanhado de informações sobre o ARM7TDMI, o processador usado pelo
Gameboy Advance. Durante o desenvolvimento do emulador, mais informações serão adicionadas 
a esse documento.

\section{Informações gerais}
	\begin{description}
		\item[Nome:] ARM7-Thumb+Debug+Multiplier+ICE
		\item[Velocidade de clock:] 16.78 MHz
		\item[Arquitetura:] RISC
		\item[Tamanho dos registradores:] 32 bit
	\end{description}

\section{Tópicos}

	\subsection{Pipeline}
		O processador usa um pipeline de 3 estágios:
		\begin{itemize}
			\item Fetch
			\item Decode
			\item Execute
		\end{itemize}
		Isso quer dizer que o PC (program counter) sempre aponta para a instrução $i-2$, onde
		$i$ é a instrução sendo executada atualmente. Por conta disso, quando o PC é usado em
		alguma instrução, o que o emulador deve usar é $PC + 2$ (mas como o emulador provavelmente
		não vai simular o pipeline, talvez esse incremento ao PC não seja necessário).
	
	\subsection{Arquitetura}
		O processador possui dois conjuntos de instruções:
		\begin{itemize}
			\item ARM, de 32 bits
			\item THUMB, de 16 bits
		\end{itemize}
		O conjunto de instruções THUMB é um subconjunto das instruções ARM, contendo as
		instruções mais utilizadas. Cada instrução THUMB tem 16 bits de comprimento, e
		possui uma instrução ARM correspondente, que realiza a mesma tarefa. Instruções
		THUMB são decodificadas em instruções ARM de 32 bits em tempo real, sem perda
		de performance (não sei se o emulador fará essa decodificação, pois para o 
		emulador isso significa perda de performance...).
		
		\emph{In Thumb state, the Program Counter (PC) uses bit 1 to select between 
		alternate halfwords.} (não entendi)
		
		Todas as exceções são tratadas no modo ARM. Se uma exceção ocorre no modo THUMB,
		o processador reverte para o modo ARM, trata a exceção e depois retorna ao
		modo THUMB.
	
	\subsection{Memória}
		O processador vê a memória como um vetor de bytes, com número crescendo a
		partir de 0. Sendo assim, bytes 0-3 contém a primeira palavra (32 bits),
		bytes 4-7 contém a segunda palavra, e assim por diante.
		
		\emph{Tentar entender melhor a seção 2.4 Data types: o alinhamento quer
		dizer que os valores dos endereços são múltiplos do número de bytes? Por
		exemplo, palavras sempre começam em endereços múltiplos de 4...)}
		
		O processador suporta tanto \emph{Big-endian} quanto \emph{Little-endian}.
		O formato padrão é \emph{Little-endian}.
		
		\subsubsection{Little-endian}
			Os bits com menor valor em uma palavra são os bits com os menores valores de
			endereçamento. (valor dos bits em uma palavra cresce com o endereçamento).
			Por exemplo, para uma palavra que começa no endereço A, o byte em A contém os
			8 bits menos significativos, o byte em A+1 contém os próximos 8 bits, etc.
		\subsubsection{Big-endian}
			Os bits com menor valor em uma palavra são os bits com os maiores valores de
			endereçamento. (valor dos bits em uma palavra diminui com o endereçamento).
			Por exemplo, para uma palavra que começa no endereço A, o byte com os 8 bits
			menos significativos está em A+3, os próximos 8 bits está em A+2, etc.
	
	\subsection{Modos de Operação}
		O processador possui sete modos de operação:
		\begin{description}
			\item[User mode:] é o modo normal de execução
			\item[Fast Interrupt (FIQ):] suporta transferência de dados (?)
			\item[Interrupt (IRQ):] usado para tratamento de interrupções
			\item[Supervisor:] modo protegido para o SO
			\item[Abort:] quando ocorre \emph{Prefetch Abort} (?)
			\item[System:] outro modo protegido para o SO
			\item[Undefined:] ativado quando instruções não definidas são executadas
		\end{description}	
	
	\subsection{Registradores}
		O processador possui 37 registradores:
		\begin{itemize}
			\item 31 registradores de 32 bits de uso geral
			\item 6 registradores de status
		\end{itemize}
		
		\subsubsection{Registradores do modo ARM}
			No modo ARM, temos:
			\begin{itemize}
				\item Registradores r0-r13 são registradores de uso geral,
					que podem guardar dados ou endereços de memória
				\item CPSR contém flags de condição e bits de modo de operação
				\item r14 é o \emph{Link Register} (LR). r14 recebe uma cópia do
					r15 quando um \emph{Branch with Link} (BL) é executado.
				\item r15 contém o PC. No modo ARM, bits 0 e 1 devem ser ignorados.
					Bits 2-31 contém o PC. No modo THUMB, bit 0 deve ser ignorado
					e os bits 1-31 contém o PC.
			\end{itemize}
			
			Por convenção, o r13 é usado como \emph{Stack pointer} (SP).
			
			Alguns modos contém registradores próprios (\emph{banked register}), que
			são mapeados para registradores do modo User/System. 
		
		\subsubsection{Registradores do modo THUMB}
			No modo THUMB temos:
			\begin{itemize}
				\item r0-r7 são registradores de uso geral
				\item o PC
				\item o SP
				\item o LR
				\item o CPSR
			\end{itemize}
		
		\subsubsection{Relação entre os registradores dos dois modos}
			Temos a seguinte relação entre os registradores dos dois modos:
			\begin{itemize}
				\item THUMB r0-r7 e ARM r0-r7 são idênticos
				\item THUMB CPSR-SPSR e ARM CPSR-SPSR são idênticos
				\item THUMB SP é o ARM r13
				\item THUMB LR é o ARM r14
				\item THUMB PC é o ARM PC (r15)
			\end{itemize}
		
		\subsubsection{CPSR e SPSR}
			Esses registradores contém o seguinte:
			\begin{itemize}
				\item informações sobre a operação ALU realizada mais recentemente
				\item status das interrupções (ligadas/desligadas)
				\item modo de operação do processador
			\end{itemize}
			
			Os bits desses registradores estão arranjados da seguinte forma:
			
			\begin{itemize}
				\item bits 0-4: modo
				\item bit 5: estado (1: THUMB, 0: ARM)
				\item bit 6: desliga FIQ
				\item bit 7: desliga IRQ
				\item bits 8-27: reservados
				\item bit 28: overflow (flag V)
				\item bit 29: carry/borrow/extend (flag C)
				\item bit 30: zero (flag Z)
				\item bit 31: neg/less than (flag N)
			\end{itemize}
			
			Sobre os 5 bits menos significativos, temos:
			
			\begin{itemize}
				\item 10000: User
				\item 10001: FIQ
				\item 10010: IRQ
				\item 10011: Supervisor
				\item 10111: Abort
				\item 11011: Undefined
				\item 11111: System
			\end{itemize}
		
	\subsection{Exceções}
		\emph{(escrever sobre as exceções, quando elas forem implementadas no emulador)}
	
	\subsection{Ciclos por Instrução}
		\emph{(escrever sobre a quantidade de ciclos que cada instrução gasta, quando
			o emulador tentar emular sincronização)}
\section{Instruções}
A seguir, trataremos das instruções suportadas pelo processador.		
\begin{figure}[H]
	\noindent\makebox[\textwidth]{%
	\includegraphics[scale=0.6]{formats.pdf}}
	\caption{Formato das instruções}
\end{figure}
	
	\subsection{Campo de condição}
		Todas as instruções são executadas condicionalmente, levando em conta o estado
		dos bits de condição do CPSR e do campo de condição da instrução. Esse campo de 
		condição corresponde aos bits 28-31 da instrução. Cada condição diferente possui
		um sufixo, que pode ser concatenado no fim da instrução. Por exemplo, BEQ é a
		instrução Branch com campo de condição EQual, ou seja, flag Z setada. Se a
		instrução não possui sufixo, o campo de de condição é Always (AL). Essa instrução
		será executada incondicionalmente.
		\\
		
		\begin{tabular}{|l|l|l|l|}
			\hline
			Código & Sufixo & Flags & Significado \\
			\hline
			\hline
			0000 & EQ & Z setada & $=$                            \\
			0001 & NE & Z não setada & $\ne$                        \\
			0010 & CS & C setada & $\ge$ (sem sinal)                \\
			0011 & CC & C não setada & $<$ (sem sinal)              \\
			0100 & MI & N setada & $< 0$                            \\
			0101 & PL & N não setada & $\ge 0$                      \\
			0110 & VS & V setada & overflow                         \\
			0111 & VC & V não setada & sem overflow                 \\
			1000 & HI & C setada e Z não setada & $>$ (sem sinal)   \\
			1001 & LS & C não setada e Z setada & $\le$ (sem sinal) \\
			1010 & GE & N igual a V & $\ge$                         \\
			1011 & LT & N diferente de V & $<$                      \\
			1100 & GT & Z não setado E (N igual a V) & $>$          \\
			1101 & LE & Z setado OU (N diferente de V) & $\le$      \\
			1110 & AL & (ignorado) & always                         \\
			\hline
		\end{tabular}
	
	\subsection{ARM - Branch and Exchange - BX}
		
		\begin{tabular}{|c|c|c|c|c|c|c|c|}
		\hline
		Cond & 0001 & 0010 & 1111 & 1111 & 1111 & 0001 & Rn \\
		\hline
		\end{tabular}
		
		Instrução executada se a condição for verdadeira. Copia o conteúdo do
		registrador Rn no PC (programa pula a execução para o endereço Rn).
		Além disso, essa instrução permite a troca do conjunto de instruções:
		se $Rn[0] = 1$, muda para THUMB; caso contráro, muda para ARM.
		
		\begin{verbatim}
		Sintaxe: BX{cond} Rn
		\end{verbatim}
	
	\subsection{ARM - Branch e Branch with Link - B, BL}
		
		\begin{tabular}{|c|c|c|c|}
		\hline
		Cond & 101 & L & offset \\
		\hline
		\end{tabular}
		
		Instrução executada somente se a condição for verdadeira. Contém um offset
		de 24 bits, em complemento de 2. Esse valor sofre um shift de 2 bits para a
		esquerda (multiplicado por 4), o sinal é extendido para 32 bits, e somado
		ao PC. Essa operação deve levar em conta o fato do PC estar 8 bytes na frente
		da instrução sendo executada atualmente. \emph{IMPORTANTE!!}
		
		Se L for setado, o valor antigo do PC é escrito no registrador r14 (LR), 
		\emph{levando em conta o modo de operação (User, etc.)}. Esse valor antigo
		é ajustado para conter o endereço da instrução seguinte à instrução BL. 
		
		\begin{verbatim}
		Sintaxe: B{L}{cond} <expressão>
		\end{verbatim}
		
	\subsection{ARM - Multiplica / Multiplica-Acumula - MUL, MLA}
		
		\begin{tabular}{|c|c|c|c|c|c|c|c|c|}
		\hline
		Cond & 000000 & A & S & Rd & Rn & Rs & 1001 & Rm \\
		\hline
		\end{tabular}
		
		Instrução executada somente se a condição for verdadeira. Realiza
		multiplicação inteira usando o algoritmo de Booth. A instrução 
		multiplica calcula $Rd = Rm * Rs$. Rn é ignorado. A instrução
		multiplica-acumula calcula $Rd = Rm * Rs + Rn$, economizando um
		ADD. Os operandos podem ser sem o com sinal (complemento de 2).
		Note que Rd deve ser diferente de Rm. Além disso, R15 não pode
		ser usado. Dependendo do bit S, essa instrução pode setar algumas
		flags: N é igual ao bit 31 do resultado; Z é setado sse o resultado
		é igual a 0; C é setado para um valor sem sentido e V não é alterado.
		
		\begin{verbatim}
		Sintaxe: 
		  MUL{cond}{S} Rd,Rm,Rs
		  MLA{cond}{S} Rd,Rm,Rs,Rn
		\end{verbatim}
		
	\subsection{ARM - Multiplicação longa - UMULL, SMULL, UMLAL, SMLAL}
		
		\begin{tabular}{|c|c|c|c|c|c|c|c|c|c|}
		\hline
		Cond & 00001 & U & A & S & RdHi & RdLo & Rs & 1001 & Rm \\
		\hline
		\end{tabular}
		
		Instrução executada somente se a condição for verdadeira. Possui 
		4 variações:
		
		UMULL e SMULL: faz $RdHi,RdLo = Rm * Rs$, sem sinal (U) ou com sinal (S);
		
		UMLAL e SMLAL: faz $RdHi,RdLo = Rm * Rs + RdHi,RdLo$, sem sinal (U) ou
		com sinal (S).
		
		Restrições: r15 não pode ser usado. Além disso, RdHi, RdLo e Rm devem ser
		registradores diferentes.
		
		As flags do CPSR são alteradas da seguinte forma: N é o bit 63 do resultado;
		Z é setado sse todos os bits do resultado são iguais a 0; C e V são setados
		para valores sem sentido.
		
		\begin{verbatim}
		Sintaxe:
		  UMULL{cond}{S} RdLo,RdHi,Rm,Rs
		  UMLAL{cond}{S} RdLo,RdHi,Rm,Rs
		  SMULL{cond}{S} RdLo,RdHi,Rm,Rs
		  SMLAL{cond}{S} RdLo,RdHi,Rm,Rs
		\end{verbatim}
	
	\subsection{ARM - Transferência de dado único - LDR, STR}
		
		\begin{tabular}{|c|c|c|c|c|c|c|c|c|c|c|}
		\hline
		Cond & 01 & I & P & U & B & W & L & Rn & Rd & Offset \\
		\hline
		\end{tabular}
		
		Instrução executada somente se a condição for verdadeira. Essa instrução
		é usada para transferir um único byte/palavra entre a memória e um registrador.
		O endereço de memória é obtido somando ou subtraindo um offset do valor que
		se encontra em um registrador. 
		
		O offset pode ser um valor imediato sem sinal de 12 bits ou um registrador + shift.
		O offset pode ser adicionado (U=1) ou subtraido (U=0) do registrador Rn (base). 
		Essa modificação pode ser realizada antes (P=1, pré-indexado) ou depois 
		(P=0, pós-indexado) da base ser usada como endereço de memória. Esse valor modificado
		pode ser escrito em Rn (W=1) ou não (W=0). \emph{(Tentar entender melhor o fato desse
		bit ser redundante para P=0)}
		
		Essa instrução pode ser usada para transferir um byte (B=1) ou uma palavra (B=0)
		entre a memória e um registrador. \emph{(o texto fala sobre como os bytes passam
		pelo barramento de memória. Não sei se isso é importante para o emulador)}
		
		Peculiaridade do registrador r15: não é necessário especificar um valor para W se
		Rn é o R15. (lembrar que R15 está adiantado em 8 bytes do valor da instrução em
		execução no momento, por conta do pipeline) R15 não pode ser o registrador do offset.
		Quando R15 é a origem de STR, o valor gravado será o valor da instrução + 12.
		
		\begin{verbatim}
		Sintaxe:
		  <LDR|STR>{cond}{B}{T} Rd,<Address>
		  <Address> pode ser:
		      <expression> -> uma expressão que gera um endereço
		      valores pré-indexados:
		        [Rn]                       -> offset = 0
		        [Rn,<#expression>]{!}      -> offset = <expression>
		        [Rn,{+/-}Rm{,<shift>}]{!}  -> offset de +- Rm, com shift
		      valores pós-indexados:
		        [Rn],<#expression>         -> offset = <expression>
		        [Rn],{+/-}Rm{,<shift>}     -> offset de +- Rm, com shift
		      {!} seta W
		\end{verbatim}
	
	\subsection{ARM - Transferência de 2 bytes (com/sem sinal) - LDRH, STRH, LDRSB, LDRSH}
		
		\begin{tabular}{|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|}
		\hline
		Cond & 000 & P & U & 0/1 & W & L & Rn & Rd & 0000/Offset & 1 & S & H & 1 & Rm/Offset \\
		\hline
		\end{tabular}
		
		Instrução executada somente quando a condição for verdadeira. Essas instruções
		são usadas para ler/gravar 2 bytes (sem sinal), além de ler 1 ou 2 bytes com sinal.
		O cálculo é realizado da mesma forma que o cálculo da instrução anterior.
		
		O offset pode ser um valor imediato de 8 bits, sem sinal, ou um outro registrador.
		Esse valor imediato é formado concatenando os bits 11-8 com os bits 3-0, tal que 
		o bit 11 se torna o bit mais significativo. U, P e W funcionam como na instrução 
		anterior. Com S=0 e H=1, ocorre a transferência de dois bytes (sem sinal) entre a
		memória e um registrador.
		
		S controla o modo com sinal. Quando S=1, H seleciona entre 1 byte (H=0) ou 2 bytes
		(H=1). L não pode ser 0 quando S=1.
		
		LDRSB carrega os bits do byte selecionado para os bits 7-0 do registrador de destino,
		e os bits 31-8 são setados com o bit 7 (sinal).
		
		LDRSH carrega os bits selecionados para os bits 15-0 do registrador de destino,
		e os bits 31-16 são setados com o bit 15 (sinal).
		
		O registrador R15 possui as mesmas peculiaridades da instrução anterior.
		
		\begin{verbatim}
		Sintaxe:
		  <LDR|STR>{cond}<H|SH|SB> Rd,<Address>
		  <Address> pode ser:
		      <expression> -> uma expressão que gera um endereço
		      valores pré-indexados:
		        [Rn]                       -> offset = 0
		        [Rn,<#expression>]{!}      -> offset = <expression>
		        [Rn,{+/-}Rm{,<shift>}]{!}  -> offset de +- Rm, com shift
		      valores pós-indexados:
		        [Rn],<#expression>         -> offset = <expression>
		        [Rn],{+/-}Rm{,<shift>}     -> offset de +- Rm, com shift
		      {!} seta W
		\end{verbatim}
	
	\subsection{ARM - Transferência de Blocos de Dados - LDM, STM}
		
		\begin{tabular}{|c|c|c|c|c|c|c|c|c|}
		\hline
		Cond & 100 & P & U & S & W & L & Rn & Register List \\
		\hline
		\end{tabular}
		
		Instrução executada somente se a condição for verdadeira. Essas intruções
		são usadas para ler ou gravar subconjuntos dos registradores visíveis
		no momento. 
		
		Na lista de registradores, cada bit representa um registrador; se o bit
		0 está setado, o registrador 0 será transferido. Essa lista não pode 
		ser vazia (= 0x0000).
		
		\emph{(depois colocarei o resto dos detalhes dessa instrução, já que ela
		é bem complicada, e quero fazer o esqueleto desse documento logo...)}
		
	\subsection{ARM - Troca de dados (simples) - SWP}
	
		\begin{tabular}{|c|c|c|c|c|c|c|c|c|}
		\hline
		Cond & 00010 & B & 00 & Rn & Rd & 0000 & 1001 & Rm \\
		\hline
		\end{tabular}
		
		Instrução executada somente se a condição é verdadeira. Essa instrução é 
		usada para trocar um byte ou uma palavra entre um registrador e a memória
		externa. Essa instrução realiza uma leitura e uma escrita atômica (o
		processador não pode ser interrompido se começou a leitura e ainda não
		terminou a escrita). 
		
		O endereço de troca é determinado por Rn. O mesmo registrador pode ser usado 
		como origem e destino. 
		
		Essa instrução pode trocar um byte (B=1) ou uma palavra (B=0). Essa instrução
		é implementada com um LDR seguido de um STR \emph{(não acho que o emulador
		vai executar a instrução dessa forma, mas quem sabe...)}. R15 não pode ser
		usado nessa instrução.
		
		\begin{verbatim}
		Sintaxe: <SWP>{cond}{B} Rd,Rm,[Rn]
		\end{verbatim}
		
	\subsection{ARM - Interrupção de Software - SWI}
		
		\begin{tabular}{|c|c|c|}
		\hline
		Cond & 1111 & Comment Field (ignored) \\
		\hline
		\end{tabular}
		
		Instrução executada somente se a condição for verdadeira. Essa instrução é
		usada para entrar no modo supervisor de maneira controlada. Durante a
		troca de modo, o PC assume um valor fixo (0x08) e o CPSR é salvo em 
		SPSR\_svc. O PC antigo é salvo em R14\_svc, ajustado de modo a apontar para
		a instrução seguinte à instrução SWI.
		
		\begin{verbatim}
		Sintaxe: SWI{cond} <expression>
		\end{verbatim}
	
	\subsection{ARM - Operações de dados do coprocessador - CDP}
		
		\begin{tabular}{|c|c|c|c|c|c|c|c|c|}
		\hline
		Cond & 1110 & CP Opc & CRn & CRd & CP\# & CP & 0 & CRm \\
		\hline
		\end{tabular}
		
		Instrução executada somente quando a condição for verdadeira. Essa instrução
		é usada para o processador dizer a um coprocessador que execute uma dada
		instrução. \emph{(sem mais detalhes pois não sei se será necessária a
		implementação dessa instrução no emulador)}
	
	\subsection{ARM - Transferência de dados do coprocessador - LDC, STC}
		
		\begin{tabular}{|c|c|c|c|c|c|c|c|c|c|c|}
		\hline
		Cond & 110 & P & U & N & W & L & Rn & CRd & CP\# & Offset\\
		\hline
		\end{tabular}
		
		Instrução executada somente quando a condição for verdadeira. Essa instrução
		é usada para transferência de dados entre os registradores do coprocessador
		e a memória externa. \emph{(sem mais detalhes pois não sei se será necessária a
		implementação dessa instrução no emulador)}
		
	\subsection{ARM - Transferência de registradores do coprocessador - MRC, MCR}
		
		\begin{tabular}{|c|c|c|c|c|c|c|c|c|c|c|}
		\hline
		Cond & 1110 & CP Opc & L & CRn & Rd & CP\# & Offset & CP & 1 & CRm\\
		\hline
		\end{tabular}
	
		Instrução executada somente quando a condição for verdadeira. Essa instrução
		é usada para comunicar informação diretamente entre o ARM7TDMI e o coprocessador.
		\emph{(sem mais detalhes pois não sei se será necessária a implementação dessa 
		instrução no emulador)}
		
	\subsection{ARM - Instrução indefinida}
	
		\begin{tabular}{|c|c|c|c|c|}
		\hline
		Cond & 011 & xxxxxxxxxxxxxxxxxxxx & 1 & xxxx\\
		\hline
		\end{tabular}
		
		Instrução executada somente se a condição for verdadeira. \emph{(Quando
		o processador encontra uma instrução dessas, acontece um monte de coisas
		que provavelmente não interessa ao emulador)}
		
	\subsection{ARM - Processamento de dados}
		
		\begin{tabular}{|c|c|c|c|c|c|c|c|}
		\hline
		Cond & 00 & I & OpCode & S & Rn & Rd & Operand2\\
		\hline
		\end{tabular}
		
		Instrução executada somente quando a condição é verdadeira. Essa instrução
		realiza uma operação lógica ou aritmética em Rn e Operand2. O primeiro
		operando (Rn) deve ser um registrador. O segundo operando pode ser um
		registrador com shift ou um valor imediato de 8 bits rotacionado, de acordo 
		com I. O CPSR pode ser atualizado ou não, dependendo do valor de S.
		
		\begin{tabular}{|c|c|l|}
		\hline
		Instrução & OpCode & Ação\\
		\hline
		\hline
		AND & 0000 & E lógico                         \\
		EOR & 0001 & $XOR$                              \\
		SUB & 0010 & $op1 - op2$                      \\
		RSB & 0011 & $op2 - op1$                        \\
		ADD & 0100 & $op1 + op2$                        \\
		ADC & 0101 & $op1 + op2 + carry$                \\
		SBC & 0110 & $op1 - op2 + carry - 1$            \\
		RSC & 0111 & $op2 - op1 + carry - 1$            \\
		TST & 1000 & E lógico (sem resultado)         \\
		TEQ & 1001 & $XOR$ (sem resultado)              \\
		CMP & 1010 & SUB (sem resultado)              \\
		CMN & 1011 & ADD (sem resultado)              \\
		ORR & 1100 & OU lógico                        \\
		MOV & 1101 & op2 (op1 é ignorado)             \\
		BIC & 1110 & op1 AND NOT op2 (bit clear)      \\
		MVN & 1111 & NOT op2 (op1 é ignorado)         \\
		\hline
		\end{tabular}
		
		Essas instruções podem ser classificadas como lógicas ou aritméticas.
		As instruções lógicas (AND, EOR, TST, TEQ, ORR, MOV, BIC, MVN) realizam
		a respectiva operação em cada bit do operando(s) para produzir o resultado. 
		Se S=1 (e $Rd \ne R15$), ocorrem as seguintes alterações nas flags do CPSR:
		V é inalterado; C contém o carry (ou é inalterado se a instrução for
		LSL \#0); Z é setada sse o resultado contém apenas bits 0; N é setado
		com o bit 31 do resultado.
		
		As instruções aritméticas (SUB, RSB, ADD, ADC, SBC, RSC, CMP, CMN) tratam
		cada operando como um inteiro de 32 bits (sem sinal o complemento de 2,
		que são equivalentes). Se S=1 (e $Rd \ne R15$), temos o seguinte: V é setado
		se ocorre overflow no bit 31 do resultado; C será o carry do bit 31 da ULA;
		Z é setado sse o resultado for 0; N é setado com o bit 31 do resultado.
		
		\subsubsection{Shifts}
			
			\begin{tabular}{|c|c|c|}
			\hline
			Amount & Shift Type & 0\\
			\hline
			\end{tabular}
			
			\begin{tabular}{|c|c|c|c|}
			\hline
			Rs & 0 & Shift Type & 1\\
			\hline
			\end{tabular}
			
			Quando o segundo operador é um registrador com shift, a operação é
			controlada pelo campo Shift Type. A quantidade pode ser especificada
			de imediato ou pelo byte menos significativo de Rs. Essa operação
			funciona como o shift em C, sendo que o bit menos (ou mais, se
			for shift right) significativo que sai do número seta a flag C do CPSR.
			
			ASR funciona de forma similar a LSR, mas os bits mais significativos 
			são preenchidos com o bit 31 de Rm, a fim de preservar o sinal em 
			complemento de 2.
			
			ROR (rotate right) realiza a rotação dos bits dentro do número. 
			
			RRX (rotate right extended) realiza a rotação dos bits do número,
			concatenado com a flag C (no fim, temos um número de 33 bits, sendo
			bit 32 = C e 31-0 o operando).
			
			\emph{(escrever sobre quantidade especificada com um registrador)}
			
		\begin{verbatim}
		Sintaxe:
		     <MOV|MVN>{cond}{S} Rd,<Op2>
		     <CMP|CMN|TEQ|TST>{cond} Rn,<Op2>
		     <AND|EOR|SUB|RSB|ADD|ADC|SBC|RSC|ORR|BIC>{cond}{S} Rd,Rn,<Op2>
		\end{verbatim}
	
	\subsection{ARM - Transferências PSR - MRS, MSR}
		
		\begin{tabular}{|c|c|c|c|c|c|}
		\hline
		Cond & 00010 & Ps & 001111 & Rd & 000000000000 \\
		\hline
		\end{tabular}
		
		\begin{tabular}{|c|c|c|c|c|c|}
		\hline
		Cond & 00010 & Pd & 1010011111 & 00000000 & Rm \\
		\hline
		\end{tabular}
		
		\begin{tabular}{|c|c|c|c|c|c|c|}
		\hline
		Cond & 00 & I & 10 & Pd & 1010001111 & Source Operand\\
		\hline
		\end{tabular}
		
		Instrução executada somente quando a condição for verdadeira.
		As instruções MSR e MRS são formadas de um subconjunto das
		instruções de processamento de dados, e são implementadas usando
		TEQ, TST, CMN, CMP, sem a flag S. Essas instruções permitem o
		acesso aos registradores CPSR e SPSR. MRS move o conteúdo de
		CPSR/SPSR\_<modo> para um registrador, e MSR faz o caminho inverso.
		Essas instruções também permitem o acesso direto às quatro flags
		do CPSR/SPSR\_<modo>.
		
		\emph{(escrever sobre os detalhes...)}
		
\section{Bibliografia}
\emph{ARM7TDMI Technical Reference Manual}, \emph{Revision: r4p1},\\
Advanced RISC Machines Ltd (ARM),\\
http://infocenter.arm.com/help/topic/com.arm.doc.ddi0210c/DDI0210B.pdf\\

\emph{ARM7TDMI Data Sheet}, \emph{Num: ARM DDI 0029E}, ARM
Advanced RISC Machines Ltd (ARM),\\
Agosto, 1995.

\end{document}
